Java Wrapper Classes - Complete Cheatsheet

A comprehensive guide to Java's wrapper classes with practical code snippets and their use cases.

Integer
Long
Character
Boolean
Double
Float
Byte & Short
String
Quick Reference Summary
Best Practices

🔹 `Integer` (for `int`)

Parsing & Conversion

// String to int/Integer
Integer.parseInt("123");           // Returns: 123 (primitive int)
Integer.valueOf("123");            // Returns: Integer object
Integer.valueOf("1010", 2);        // Binary to int: 10
Integer.decode("0x1A");            // Hex to int: 26

// int to String
Integer.toString(42);              // Returns: "42"
Integer.toString(10, 2);           // Binary: "1010"
Integer.toString(255, 16);         // Hex: "ff"

Math Operations

Integer.max(10, 20);               // Returns: 20
Integer.min(10, 20);               // Returns: 10
Integer.sum(10, 20);               // Returns: 30
Integer.compare(5, 7);             // Returns: -1 (since 5 < 7)
Math.abs(-15);                     // Returns: 15

Bit Operations

Integer.bitCount(7);               // Number of 1-bits: 3
Integer.toBinaryString(10);        // Returns: "1010"
Integer.toHexString(255);          // Returns: "ff"
Integer.toOctalString(8);          // Returns: "10"
Integer.highestOneBit(12);         // Returns: 8 (1000 in binary)
Integer.numberOfLeadingZeros(8);   // Returns: 28
Integer.reverse(0b1100);           // Reverses bits

Constants

Integer.MAX_VALUE;                 // 2,147,483,647
Integer.MIN_VALUE;                 // -2,147,483,648
Integer.SIZE;                      // 32 (bits)

🔹 `Long` (for `long`)

Parsing & Conversion

// String to long
Long.parseLong("123456789");       // Returns: 123456789L
Long.valueOf("123456789");         // Returns: Long object
Long.decode("0x1FFFFFFFFL");       // Hex to long

// long to String
Long.toString(12345L);             // Returns: "12345"
Long.toString(1024L, 2);           // Binary: "10000000000"

Math Operations

Long.max(100L, 200L);              // Returns: 200L
Long.min(100L, 200L);              // Returns: 100L
Long.sum(100L, 200L);              // Returns: 300L
Long.compare(5L, 7L);              // Returns: -1

Bit Operations

Long.bitCount(15L);                // Number of 1-bits: 4
Long.toBinaryString(10L);          // Returns: "1010"
Long.toHexString(255L);            // Returns: "ff"
Long.numberOfLeadingZeros(16L);    // Returns: 59
Long.highestOneBit(12L);           // Returns: 8L

Constants

Long.MAX_VALUE;                    // 9,223,372,036,854,775,807
Long.MIN_VALUE;                    // -9,223,372,036,854,775,808
Long.SIZE;                         // 64 (bits)

🔹 `Character` (for `char`)

Character Type Checking

Character.isDigit('5');            // true
Character.isLetter('A');           // true
Character.isLetterOrDigit('7');    // true
Character.isUpperCase('A');        // true
Character.isLowerCase('a');        // true
Character.isWhitespace(' ');       // true
Character.isAlphabetic('α');       // true (Unicode letters)
Character.isDefined('€');          // true (valid Unicode)

Case Conversion

Character.toUpperCase('a');        // Returns: 'A'
Character.toLowerCase('B');        // Returns: 'b'
Character.toTitleCase('a');        // Returns: 'A'

Numeric & Special

Character.getNumericValue('9');    // Returns: 9
Character.getNumericValue('A');    // Returns: 10 (hex)
Character.toString('x');           // Returns: "x"
Character.compare('a', 'b');       // Returns: -1

Constants

Character.MAX_VALUE;               // '\uffff' (65535)
Character.MIN_VALUE;               // '\u0000' (0)
Character.SIZE;                    // 16 (bits)

🔹 `Boolean` (for `boolean`)

Parsing & Conversion

Boolean.parseBoolean("true");      // Returns: true
Boolean.parseBoolean("TRUE");      // Returns: true
Boolean.parseBoolean("yes");       // Returns: false (only "true" works)
Boolean.valueOf("false");          // Returns: Boolean.FALSE
Boolean.toString(true);            // Returns: "true"

Logical Operations

Boolean.logicalAnd(true, false);   // Returns: false
Boolean.logicalOr(true, false);    // Returns: true
Boolean.logicalXor(true, true);    // Returns: false
Boolean.compare(true, false);      // Returns: 1

Constants

Boolean.TRUE;                      // Boolean object for true
Boolean.FALSE;                     // Boolean object for false

🔹 `Double` (for `double`)

Parsing & Conversion

Double.parseDouble("3.14159");     // Returns: 3.14159
Double.valueOf("2.718");           // Returns: Double object
Double.toString(3.14);             // Returns: "3.14"
Double.toHexString(1.0);           // Returns: "0x1.0p0"

Special Value Checking

Double.isNaN(Math.sqrt(-1));       // true (Not a Number)
Double.isInfinite(1.0 / 0.0);      // true
Double.isFinite(3.14);             // true
Double.compare(3.5, 4.5);          // Returns: -1

Math Operations

Double.max(3.5, 4.5);              // Returns: 4.5
Double.min(3.5, 4.5);              // Returns: 3.5
Double.sum(2.5, 3.5);              // Returns: 6.0
Math.abs(-3.14);                   // Returns: 3.14

Constants

Double.MAX_VALUE;                  // 1.7976931348623157E308
Double.MIN_VALUE;                  // 4.9E-324 (smallest positive)
Double.POSITIVE_INFINITY;          // Positive infinity
Double.NEGATIVE_INFINITY;          // Negative infinity
Double.NaN;                        // Not a Number

🔹 `Float` (for `float`)

Parsing & Conversion

Float.parseFloat("3.14f");         // Returns: 3.14f
Float.valueOf("2.718f");           // Returns: Float object
Float.toString(3.14f);             // Returns: "3.14"

Special Value Checking

Float.isNaN(0.0f / 0.0f);          // true
Float.isInfinite(1.0f / 0.0f);     // true
Float.isFinite(3.14f);             // true
Float.compare(3.5f, 4.5f);         // Returns: -1

Constants

Float.MAX_VALUE;                   // 3.4028235E38
Float.MIN_VALUE;                   // 1.4E-45
Float.POSITIVE_INFINITY;           // Positive infinity
Float.NEGATIVE_INFINITY;           // Negative infinity
Float.NaN;                         // Not a Number

🔹 `Byte` & `Short`

Byte Operations

Byte.parseByte("127");             // Returns: 127 (byte)
Byte.toString((byte) 65);          // Returns: "65"
Byte.valueOf("42");                // Returns: Byte object
Byte.compare((byte) 5, (byte) 7);  // Returns: -1

// Constants
Byte.MAX_VALUE;                    // 127
Byte.MIN_VALUE;                    // -128

Short Operations

Short.parseShort("32767");         // Returns: 32767 (short)
Short.toString((short) 1000);      // Returns: "1000"
Short.valueOf("500");              // Returns: Short object
Short.compare((short) 5, (short) 7); // Returns: -1

// Constants
Short.MAX_VALUE;                   // 32767
Short.MIN_VALUE;                   // -32768

🔹 `String` (Special Reference Type)

Length & Checking

String s = "  Hello World  ";
s.length();                        // Returns: 15
s.isEmpty();                       // Returns: false
"".isEmpty();                      // Returns: true
s.isBlank();                       // Returns: false (Java 11+)
"   ".isBlank();                   // Returns: true (Java 11+)

Content Checking

s.contains("Hello");               // Returns: true
s.startsWith("  He");              // Returns: true
s.endsWith("ld  ");                // Returns: true
s.equals("  Hello World  ");       // Returns: true
s.equalsIgnoreCase("  HELLO world  "); // Returns: true

Manipulation

s.trim();                          // Returns: "Hello World"
s.strip();                         // Returns: "Hello World" (Java 11+)
s.toUpperCase();                   // Returns: "  HELLO WORLD  "
s.toLowerCase();                   // Returns: "  hello world  "
s.replace("World", "Java");        // Returns: "  Hello Java  "
s.replaceAll("\\s+", " ");         // Regex: replace multiple spaces with single space
s.substring(2, 7);                 // Returns: "Hello"
s.repeat(3);                       // Returns: "  Hello World    Hello World    Hello World  " (Java 11+)

Splitting & Joining

s.split(" ");                      // Returns: ["", "", "Hello", "World", "", ""]
s.split("\\s+");                   // Split on any whitespace: ["", "Hello", "World", ""]
String.join(", ", "A", "B", "C");  // Returns: "A, B, C"
String.join("-", Arrays.asList("X", "Y", "Z")); // Returns: "X-Y-Z"

Indexing & Searching

s.charAt(4);                       // Returns: 'l'
s.indexOf("o");                    // Returns: 4 (first occurrence)
s.lastIndexOf("o");                // Returns: 7 (last occurrence)
s.indexOf("World", 5);             // Search starting from index 5

Conversion

String.valueOf(123);               // Returns: "123"
String.valueOf(3.14);              // Returns: "3.14"
String.valueOf(true);              // Returns: "true"
String.valueOf(new char[]{'A', 'B'}); // Returns: "AB"
"42".getBytes();                   // Returns: byte array

🚀 Quick Reference Summary

Class	Key Methods	Primary Use Cases
Integer	`parseInt()`, `valueOf()`, `toString()`, `max()`, `min()`, `bitCount()`	String conversion, math ops, bit manipulation
Long	`parseLong()`, `valueOf()`, `toString()`, `max()`, `min()`	Large number operations, bit manipulation
Character	`isDigit()`, `isLetter()`, `toUpperCase()`, `toLowerCase()`	Character validation and transformation
Boolean	`parseBoolean()`, `valueOf()`, `logicalAnd()`, `logicalOr()`	Boolean parsing and logical operations
Double/Float	`parseDouble()`, `isNaN()`, `isInfinite()`, `compare()`	Decimal number operations, special value checking
String	`trim()`, `split()`, `contains()`, `substring()`, `replace()`	Text manipulation, searching, formatting

🎯 Best Practices

Prefer valueOf() over constructors - Uses cached instances for small numbers
Handle NumberFormatException - Always catch when parsing strings
Use equals() for object comparison - Don't use == with wrapper objects
Consider autoboxing/unboxing overhead - Be mindful in performance-critical code
Null-safe operations - Wrapper objects can be null, primitives cannot

// Good practices
Integer num = Integer.valueOf("123"); // Uses cache
if (Objects.equals(num1, num2)) { }   // Null-safe comparison

// Avoid
Integer num = new Integer("123");     // Deprecated, creates new instance
if (num1 == num2) { }                 // Unsafe reference comparison

📋 Quick Navigation​

🔹 Integer (for int)​

Parsing & Conversion​

Math Operations​

Bit Operations​

Constants​

🔹 Long (for long)​

Parsing & Conversion​

Math Operations​

Bit Operations​

Constants​

🔹 Character (for char)​

Character Type Checking​

Case Conversion​

Numeric & Special​

Constants​

🔹 Boolean (for boolean)​

Parsing & Conversion​

Logical Operations​

Constants​

🔹 Double (for double)​

Parsing & Conversion​

Special Value Checking​

Math Operations​

Constants​

🔹 Float (for float)​

Parsing & Conversion​

Special Value Checking​

Constants​

🔹 Byte & Short​

Byte Operations​

Short Operations​

🔹 String (Special Reference Type)​

Length & Checking​

Content Checking​

Manipulation​

Splitting & Joining​

Indexing & Searching​

Conversion​

🚀 Quick Reference Summary​

🎯 Best Practices​

📋 Quick Navigation

🔹 `Integer` (for `int`)

Parsing & Conversion

Math Operations

Bit Operations

Constants

🔹 `Long` (for `long`)

Parsing & Conversion

Math Operations

Bit Operations

Constants

🔹 `Character` (for `char`)

Character Type Checking

Case Conversion

Numeric & Special

Constants

🔹 `Boolean` (for `boolean`)

Parsing & Conversion

Logical Operations

Constants

🔹 `Double` (for `double`)

Parsing & Conversion

Special Value Checking

Math Operations

Constants

🔹 `Float` (for `float`)

Parsing & Conversion

Special Value Checking

Constants

🔹 `Byte` & `Short`

Byte Operations

Short Operations

🔹 `String` (Special Reference Type)

Length & Checking

Content Checking

Manipulation

Splitting & Joining

Indexing & Searching

Conversion

🚀 Quick Reference Summary

🎯 Best Practices